package impl;

import anaydis.sort.SorterType;
import org.jetbrains.annotations.NotNull;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class QuickSorterNonRecursive extends AbstractSorter{

    public QuickSorterNonRecursive(){
        super(SorterType.QUICK_NON_RECURSIVE);
    }

    protected QuickSorterNonRecursive(final SorterType type){
        super(type);
    }

    public <T> void sort(Comparator<T> tComparator, List<T> ts){
        List<Integer> pivotes = new ArrayList<Integer>();
        pivotes.add(0);
        pivotes.add(ts.size());
        int i = 0;
        while((i*2)+1<pivotes.size()){
            if(Math.abs(pivotes.get((2*i)+1) - pivotes.get(2*i)) > 2){
                int g = partition(tComparator, ts, pivotes.get(2*i) , pivotes.get((2*i)+1), (pivotes.get((2*i)+1))-1);
                pivotes.add(pivotes.get(2*i));
                pivotes.add(g);
                pivotes.add(g);
                pivotes.add(pivotes.get((2*i)+1));
            }
            i++;
        }
    }

    /*partition ubica el pivote en su posicion final, y a todos los mayores
    *a el a la derecha y los menores o iguales a izquierda.
    *Return indice final del pivote
    */

    protected <T> int partition(Comparator<T> tComparator, List<T> ts,int desde, int hasta, int pivote){
        int i = desde;
        int j = hasta-2;
        boolean end = false;
        swap(ts, pivote, hasta-1);
        pivote = hasta-1;
        do{
            boolean imayor = false;
            do{                         //busca el primer elemento mayor al pivote
                if(greater(tComparator, ts, i,pivote)){
                    imayor = true;
                }else{
                    i++;
                }
            }while((!imayor) && i<j+1);     // si i>=j+1, entonces los indices se cruzaron y "i" es la posicion final del pivote
                boolean jmenor = false;
                do{                         //busca el ultimo elemento menor al pivote
                    if(!(greater(tComparator, ts, j,pivote))){
                        jmenor = true;
                    }else{
                        j--;
                    }
                }while((!jmenor) && i<j+1);
                if(i<j){                    //si los indices no se cruzaron todavia, intercambia los elementos
                    swap(ts, i, j);
                }
                else{                       //si ya se cruzaron, ubica el pivote en su nueva posicion
                    swap(ts,i,pivote);
                    end = true;
                }
        }while(!end);
        System.out.println("Valor del pivote: "+ts.get(i));
        System.out.println("Posicion final pivote: "+i);
        return i;
    }

    @NotNull
    public SorterType getType(){
        return SorterType.QUICK_NON_RECURSIVE;
    }
}